Python FastAPI Zadania w Tle: Opanowanie Asynchronicznego Wykonywania Zadań dla Aplikacji Globalnych

W dzisiejszym połączonym cyfrowym krajobrazie, budowanie aplikacji, które mogą efektywnie obsługiwać dużą liczbę żądań, jest najważniejsze. Dla aplikacji globalnych, zwłaszcza tych, które obsługują zróżnicowane bazy użytkowników i geograficznie rozproszone operacje, wydajność i responsywność są nie tylko pożądane – są niezbędne. Framework FastAPI Pythona, znany ze swojej szybkości i produktywności programistów, oferuje solidne rozwiązanie do zarządzania zadaniami, które nie powinny blokować głównego cyklu żądanie-odpowiedź: zadania w tle.

Ten kompleksowy przewodnik zagłębi się w zadania w tle FastAPI, wyjaśniając, jak działają, dlaczego są kluczowe dla asynchronicznego wykonywania zadań i jak je efektywnie wdrażać. Omówimy różne scenariusze, zbadamy integrację z popularnymi bibliotekami kolejek zadań i dostarczymy praktycznych wskazówek dotyczących budowania skalowalnych, wysokowydajnych globalnych usług internetowych.

Zrozumienie Potrzeby Zadań w Tle

Wyobraź sobie, że użytkownik inicjuje działanie w twojej aplikacji, które obejmuje czasochłonną operację. Może to być cokolwiek, od wysyłania masowej wiadomości e-mail do tysięcy subskrybentów na różnych kontynentach, przetwarzania dużego przesłanego obrazu, generowania złożonego raportu lub synchronizowania danych z usługą zdalną w innej strefie czasowej. Jeśli te operacje są wykonywane synchronicznie w ramach obsługi żądania, żądanie użytkownika zostanie wstrzymane do czasu zakończenia całej operacji. To może prowadzić do:

• Słabe Doświadczenie Użytkownika: Użytkownicy czekają przez dłuższy czas, co prowadzi do frustracji i potencjalnego porzucenia aplikacji.
• Zatrzymana Pętla Zdarzeń: W asynchronicznych frameworkach, takich jak FastAPI (który używa asyncio), blokowanie operacji może zatrzymać całą pętlę zdarzeń, uniemożliwiając przetwarzanie innych żądań. To poważnie wpływa na skalowalność i przepustowość.
• Zwiększone Obciążenie Serwera: Długotrwałe żądania zajmują zasoby serwera, zmniejszając liczbę współbieżnych użytkowników, których twoja aplikacja może skutecznie obsługiwać.
• Potencjalne Przekroczenia Czasu: Pośrednicy sieciowi lub klienci mogą przekroczyć limit czasu oczekiwania na odpowiedź, co prowadzi do niekompletnych operacji i błędów.

Zadania w tle zapewniają eleganckie rozwiązanie, oddzielając te długotrwałe, niekrytyczne operacje od głównego procesu obsługi żądań. Pozwala to twojemu API szybko odpowiadać użytkownikowi, potwierdzając, że zadanie zostało zainicjowane, podczas gdy rzeczywista praca jest wykonywana asynchronicznie w tle.

Wbudowane Zadania w Tle FastAPI

FastAPI oferuje prosty mechanizm wykonywania zadań w tle bez potrzeby zewnętrznych zależności dla prostych przypadków użycia. Klasa `BackgroundTasks` jest przeznaczona do tego celu.

Jak Działa `BackgroundTasks`

Kiedy żądanie trafia do twojej aplikacji FastAPI, możesz wstrzyknąć instancję `BackgroundTasks` do funkcji operacji ścieżki. Ten obiekt działa jako kontener do przechowywania funkcji, które powinny być wykonane po wysłaniu odpowiedzi do klienta.

Oto podstawowa struktura:

            from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def send_email_background(email: str, message: str):
    # Simulate sending an email
    print(f"Simulating sending email to {email} with message: {message}")
    # In a real application, this would involve SMTP or an email service API.
    # For global applications, consider time zone aware sending and retry mechanisms.

@app.post("/send-notification/{email}")
async def send_notification(email: str, message: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(send_email_background, email, message)
    return {"message": "Notification sent in background"}

            

              
                Copy
              
            
          

W tym przykładzie:

• Definiujemy funkcję `send_email_background`, która zawiera logikę zadania.
• Wstrzykujemy `BackgroundTasks` jako parametr do naszej funkcji operacji ścieżki `send_notification`.
• Używając `background_tasks.add_task()`, planujemy wykonanie `send_email_background`. Argumenty dla funkcji zadania są przekazywane jako kolejne argumenty do `add_task`.
• API natychmiast zwraca komunikat o sukcesie do klienta, podczas gdy proces wysyłania wiadomości e-mail kontynuuje się w tle.

Kluczowe Kwestie dotyczące `BackgroundTasks`

• Cykl Życia Procesu: Zadania dodane za pomocą `BackgroundTasks` działają w tym samym procesie Pythona co twoja aplikacja FastAPI. Jeśli proces aplikacji zostanie ponownie uruchomiony lub ulegnie awarii, wszystkie oczekujące zadania w tle zostaną utracone.
• Brak Trwałości: Nie ma wbudowanego mechanizmu ponawiania nieudanych zadań lub utrwalania ich, jeśli serwer ulegnie awarii.
• Ograniczone dla Złożonych Przepływów Pracy: Chociaż doskonałe dla prostych operacji typu „odpal i zapomnij”, `BackgroundTasks` może nie być wystarczające dla złożonych przepływów pracy obejmujących systemy rozproszone, zarządzanie stanem lub gwarantowane wykonanie.
• Obsługa Błędów: Błędy w zadaniach w tle będą domyślnie rejestrowane, ale nie zostaną przekazane z powrotem do klienta ani nie wpłyną na początkową odpowiedź. Potrzebujesz jawnej obsługi błędów w swoich funkcjach zadań.

Pomimo tych ograniczeń, natywne `BackgroundTasks` FastAPI to potężne narzędzie do poprawy responsywności w wielu typowych scenariuszach, zwłaszcza w przypadku aplikacji, w których natychmiastowe zakończenie zadania nie jest krytyczne.

Kiedy Używać Zewnętrznych Kolejek Zadań

Aby uzyskać bardziej solidne, skalowalne i odporne przetwarzanie zadań w tle, zwłaszcza w wymagających środowiskach globalnych, zaleca się integrację z dedykowanymi systemami kolejek zadań. Systemy te oferują takie funkcje jak:

• Oddzielenie: Zadania są przetwarzane przez oddzielne procesy robocze, całkowicie niezależne od twojego serwera internetowego.
• Trwałość: Zadania mogą być przechowywane w bazie danych lub brokerze wiadomości, co pozwala im przetrwać ponowne uruchomienia lub awarie serwera.
• Ponawianie i Obsługa Błędów: Zaawansowane mechanizmy automatycznego ponawiania nieudanych zadań i obsługi błędów.
• Skalowalność: Możesz skalować liczbę procesów roboczych niezależnie od serwera internetowego, aby obsługiwać zwiększone obciążenie zadaniami.
• Monitorowanie i Zarządzanie: Narzędzia do monitorowania kolejek zadań, sprawdzania stanu zadań i zarządzania pracownikami.
• Systemy Rozproszone: Niezbędne dla architektur mikroserwisowych, gdzie zadania mogą wymagać przetworzenia przez różne usługi lub na różnych maszynach.

Kilka popularnych bibliotek kolejek zadań integruje się bezproblemowo z Pythonem i FastAPI:

1. Celery

Celery to jeden z najpopularniejszych i najpotężniejszych rozproszonych systemów kolejek zadań dla Pythona. Jest bardzo elastyczny i może być używany z różnymi brokerami wiadomości, takimi jak RabbitMQ, Redis lub Amazon SQS.

Konfigurowanie Celery z FastAPI

Wymagania wstępne:

• Zainstaluj Celery i brokera wiadomości (np. Redis):

            pip install celery[redis] 

            

              
                Copy
              
            
          

1. Utwórz plik aplikacji Celery (np. `celery_worker.py`):

            from celery import Celery

# Configure Celery
# Use a broker URL, e.g., Redis running on localhost
celery_app = Celery(
    'tasks',
    broker='redis://localhost:6379/0',
    backend='redis://localhost:6379/0'
)

# Optional: Define tasks here or import them from other modules
@celery_app.task
def process_data(data: dict):
    # Simulate a long-running data processing task.
    # In a global app, consider multi-language support, internationalization (i18n),
    # and localization (l10n) for any text processing.
    print(f"Processing data: {data}")
    # For internationalization, ensure data formats (dates, numbers) are handled correctly.
    return f"Processed: {data}"

            

              
                Copy
              
            
          

2. Zintegruj z twoją aplikacją FastAPI (`main.py`):

            from fastapi import FastAPI
from celery_worker import celery_app  # Import your Celery app

app = FastAPI()

@app.post("/process-data/")
async def start_data_processing(data: dict):
    # Send the task to Celery
    task = celery_app.send_task('tasks.process_data', args=[data])
    return {"message": "Data processing started", "task_id": task.id}

# Endpoint to check task status (optional but recommended)
@app.get("/task-status/{task_id}")
async def get_task_status(task_id: str):
    task_result = celery_app.AsyncResult(task_id)
    return {
        "task_id": task_id,
        "status": str(task_result.status),
        "result": task_result.result if task_result.ready() else None
    }

            

              
                Copy
              
            
          

3. Uruchom pracownika Celery:

W osobnym terminalu przejdź do katalogu projektu i uruchom:

            
celery -A celery_worker worker --loglevel=info

            

              
                Copy
              
            
          

4. Uruchom twoją aplikację FastAPI:

            
uvicorn main:app --reload

            

              
                Copy
              
            
          

Globalne Uwagi dotyczące Celery:

• Wybór Brokera: Dla aplikacji globalnych rozważ brokerów wiadomości, które są wysoce dostępne i rozproszone, takie jak Amazon SQS lub zarządzane usługi Kafka, aby uniknąć pojedynczych punktów awarii.
• Strefy Czasowe: Podczas planowania zadań lub przetwarzania danych wrażliwych na czas, zapewnij spójną obsługę stref czasowych w całej aplikacji i pracownikach. Użyj UTC jako standardu.
• Internacjonalizacja (i18n) i Lokalizacja (l10n): Jeśli twoje zadania w tle obejmują generowanie treści (e-maile, raporty), upewnij się, że są zlokalizowane dla różnych regionów.
• Współbieżność i Przepustowość: Dostosuj liczbę pracowników Celery i ich ustawienia współbieżności w oparciu o oczekiwane obciążenie i dostępne zasoby serwera w różnych regionach.

2. Redis Queue (RQ)

RQ to prostsza alternatywa dla Celery, również zbudowana na bazie Redis. Jest często preferowana dla mniejszych projektów lub gdy pożądana jest mniej złożona konfiguracja.

Konfigurowanie RQ z FastAPI

Wymagania wstępne:

• Zainstaluj RQ i Redis:

            
pip install rq

            

              
                Copy
              
            
          

1. Utwórz plik zadań (np. `tasks.py`):

            import time

def send_international_email(recipient: str, subject: str, body: str):
    # Simulate sending an email, considering international mail servers and delivery times.
    print(f"Sending email to {recipient} with subject: {subject}")
    time.sleep(5) # Simulate work
    print(f"Email sent to {recipient}.")
    return f"Email sent to {recipient}"

            

              
                Copy
              
            
          

2. Zintegruj z twoją aplikacją FastAPI (`main.py`):

            from fastapi import FastAPI
from redis import Redis
from rq import Queue

app = FastAPI()

# Connect to Redis
redis_conn = Redis(host='localhost', port=6379, db=0)

# Create an RQ queue
q = Queue(connection=redis_conn)

@app.post("/send-email-rq/")
def send_email_rq(
    recipient: str,
    subject: str,
    body: str
):
    # Enqueue the task
    task = q.enqueue(send_international_email, recipient, subject, body)
    return {"message": "Email scheduled for sending", "task_id": task.id}

# Endpoint to check task status (optional)
@app.get("/task-status-rq/{task_id}")
def get_task_status_rq(task_id: str):
    job = q.fetch_job(task_id)
    if job:
        return {
            "task_id": task_id,
            "status": job.get_status(),
            "result": job.result if job.is_finished else None
        }
    return {"message": "Task not found"}

            

              
                Copy
              
            
          

3. Uruchom pracownika RQ:

W osobnym terminalu:

            
python -m rq worker default

            

              
                Copy
              
            
          

4. Uruchom twoją aplikację FastAPI:

            
uvicorn main:app --reload

            

              
                Copy
              
            
          

Globalne Uwagi dotyczące RQ:

• Dostępność Redis: Upewnij się, że twoja instancja Redis jest wysoce dostępna i potencjalnie geo-rozproszona, jeśli twoja aplikacja obsługuje globalną publiczność o niskich wymaganiach dotyczących opóźnień. Zarządzane usługi Redis to dobra opcja.
• Ograniczenia Skalowalności: Chociaż RQ jest prostszy, skalowanie go może wymagać więcej ręcznego wysiłku w porównaniu z rozbudowanymi narzędziami Celery dla środowisk rozproszonych.

3. Inne Kolejki Zadań (np. Dramatiq, Apache Kafka z KafkaJS/Faust)

W zależności od twoich konkretnych potrzeb, inne rozwiązania kolejek zadań mogą być bardziej odpowiednie:

• Dramatiq: Prostsza, bardziej nowoczesna alternatywa dla Celery, obsługująca również Redis i RabbitMQ.
• Apache Kafka: Dla aplikacji wymagających wysokiej przepustowości, odporności na błędy i możliwości przetwarzania strumieniowego, Kafka może być używany jako broker wiadomości dla zadań w tle. Biblioteki takie jak Faust zapewniają pythoniczny framework przetwarzania strumieniowego na bazie Kafka. Jest to szczególnie istotne dla aplikacji globalnych z ogromnymi strumieniami danych.

Projektowanie Globalnych Przepływów Pracy Zadań w Tle

Podczas budowania systemów zadań w tle dla globalnej publiczności, kilka czynników wymaga starannego rozważenia poza podstawową implementacją:

1. Dystrybucja Geograficzna i Opóźnienia

Użytkownicy na całym świecie będą wchodzić w interakcje z twoim API z różnych lokalizacji. Umiejscowienie twoich serwerów internetowych i twoich pracowników zadań może znacząco wpłynąć na wydajność.

• Umiejscowienie Pracowników: Rozważ wdrożenie pracowników zadań w regionach geograficznie bliższych źródłom danych lub usługom, z którymi wchodzą w interakcje. Na przykład, jeśli zadanie obejmuje przetwarzanie danych z europejskiego centrum danych, umieszczenie pracowników w Europie może zmniejszyć opóźnienia.
• Lokalizacja Brokera Wiadomości: Upewnij się, że twój broker wiadomości jest dostępny z niskim opóźnieniem ze wszystkich twoich serwerów internetowych i instancji pracowników. Zarządzane usługi w chmurze, takie jak AWS SQS, Google Cloud Pub/Sub lub Azure Service Bus, oferują globalne opcje dystrybucji.
• CDN dla Zasobów Statycznych: Jeśli zadania w tle generują raporty lub pliki, które użytkownicy pobierają, użyj Sieci Dostarczania Treści (CDN), aby udostępniać te zasoby globalnie.

2. Strefy Czasowe i Planowanie

Prawidłowa obsługa czasu jest krytyczna dla aplikacji globalnych. Zadania w tle mogą wymagać zaplanowania na określone godziny lub uruchomienia na podstawie zdarzeń występujących w różnym czasie.

• Używaj UTC: Zawsze przechowuj i przetwarzaj znaczniki czasu w skoordynowanym czasie uniwersalnym (UTC). Konwertuj na lokalne strefy czasowe tylko do celów wyświetlania.
• Zaplanowane Zadania: Jeśli musisz uruchamiać zadania o określonych godzinach (np. codzienne raporty), upewnij się, że twój mechanizm planowania uwzględnia różne strefy czasowe. Celery Beat, na przykład, obsługuje planowanie w stylu cron, które można skonfigurować do uruchamiania zadań o określonych godzinach globalnie.
• Triggery Zdarzeniowe: W przypadku zadań opartych na zdarzeniach, upewnij się, że znaczniki czasu zdarzeń są standaryzowane na UTC.

3. Internacjonalizacja (i18n) i Lokalizacja (l10n)

Jeśli twoje zadania w tle generują treści skierowane do użytkowników, takie jak e-maile, powiadomienia lub raporty, muszą być zlokalizowane.

• Biblioteki i18n: Użyj bibliotek i18n Pythona (np. `gettext`, `babel`) do zarządzania tłumaczeniami.
• Zarządzanie Ustawieniami Regionalnymi: Upewnij się, że przetwarzanie zadań w tle może określić preferowane ustawienia regionalne użytkownika, aby generować treści w poprawnym języku i formacie.
• Formatowanie: Formaty daty, godziny, liczb i walut różnią się znacznie w zależności od regionu. Zaimplementuj solidną logikę formatowania.

4. Obsługa Błędów i Ponawianie

Niestabilność sieci, przejściowe awarie usług lub niespójności danych mogą prowadzić do awarii zadań. Odporny system jest kluczowy dla globalnych operacji.

• Idempotentność: Projektuj zadania tak, aby były idempotentne, gdzie to możliwe, co oznacza, że można je wykonywać wielokrotnie bez zmiany wyniku poza początkowym wykonaniem. Jest to niezbędne dla bezpiecznych ponowień.
• Wycofywanie Wykładnicze: Zaimplementuj wycofywanie wykładnicze dla ponowień, aby uniknąć przeciążania usług, które doświadczają tymczasowych problemów.
• Kolejki Martwych Liter (DLQ): W przypadku krytycznych zadań skonfiguruj DLQ do przechwytywania zadań, które wielokrotnie kończą się niepowodzeniem, umożliwiając ręczną inspekcję i rozwiązanie bez blokowania głównej kolejki zadań.

5. Bezpieczeństwo

Zadania w tle często wchodzą w interakcje z danymi wrażliwymi lub usługami zewnętrznymi.

• Uwierzytelnianie i Autoryzacja: Upewnij się, że zadania uruchamiane w tle mają niezbędne poświadczenia i uprawnienia, ale nie więcej niż jest to wymagane.
• Szyfrowanie Danych: Jeśli zadania obsługują dane wrażliwe, upewnij się, że są one szyfrowane zarówno w tranzycie (między usługami i pracownikami), jak i w spoczynku (w brokerach wiadomości lub bazach danych).
• Zarządzanie Tajemnicami: Używaj bezpiecznych metod do zarządzania kluczami API, poświadczeniami bazy danych i innymi tajemnicami potrzebnymi pracownikom w tle.

6. Monitorowanie i Obserwowalność

Zrozumienie stanu i wydajności twojego systemu zadań w tle jest niezbędne do rozwiązywania problemów i optymalizacji.

• Logowanie: Zaimplementuj kompleksowe logowanie w swoich zadaniach, w tym znaczniki czasu, identyfikatory zadań i odpowiedni kontekst.
• Metryki: Zbieraj metryki dotyczące czasów wykonania zadań, wskaźników sukcesu, wskaźników awarii, długości kolejek i wykorzystania pracowników.
• Śledzenie: Rozproszone śledzenie może pomóc w wizualizacji przepływu żądań i zadań w wielu usługach, ułatwiając identyfikację wąskich gardeł i błędów. Można zintegrować narzędzia takie jak Jaeger lub OpenTelemetry.

Najlepsze Praktyki Wdrażania Zadań w Tle w FastAPI

Niezależnie od tego, czy używasz wbudowanych `BackgroundTasks` FastAPI, czy zewnętrznej kolejki zadań, postępuj zgodnie z tymi najlepszymi praktykami:

• Utrzymuj Zadania Skoncentrowane i Atomowe: Każde zadanie w tle powinno idealnie wykonywać pojedynczą, dobrze zdefiniowaną operację. To sprawia, że są łatwiejsze do testowania, debugowania i ponawiania.
• Projektuj z Myślą o Awariach: Załóż, że zadania zakończą się niepowodzeniem. Zaimplementuj solidną obsługę błędów, logowanie i mechanizmy ponawiania.
• Minimalizuj Zależności: Pracownicy w tle powinni mieć tylko niezbędne zależności, aby efektywnie wykonywać swoje zadania.
• Optymalizuj Serializację Danych: Jeśli przekazujesz złożone dane między twoim API a pracownikami, wybierz wydajny format serializacji (np. JSON, Bufory Protokółów).
• Testuj Dokładnie: Testuj jednostkowo funkcje zadań i integruj komunikację między twoją aplikacją FastAPI a kolejką zadań.
• Monitoruj Swoje Kolejki: Regularnie sprawdzaj stan swoich kolejek zadań, wydajność pracowników i wskaźniki błędów.
• Używaj Operacji Asynchronicznych W Zadaniach, Gdzie To Możliwe: Jeśli twoje zadanie w tle musi wykonywać wywołania I/O (np. do innych API lub baz danych), użyj bibliotek asynchronicznych (takich jak `httpx` dla żądań HTTP lub `asyncpg` dla PostgreSQL) w swoich funkcjach zadań, jeśli wybrany uruchamiacz kolejki zadań to obsługuje (np. Celery z `apply_async` używającym `countdown` lub `eta` do planowania, lub pracownicy `gevent`/`eventlet`). To może dodatkowo poprawić wydajność.

Przykładowy Scenariusz: Globalne Przetwarzanie Zamówień E-commerce

Rozważ platformę e-commerce z użytkownikami na całym świecie. Kiedy użytkownik składa zamówienie, musi nastąpić kilka działań:

• Powiadom klienta: Wyślij e-mail z potwierdzeniem zamówienia.
• Zaktualizuj inwentarz: Zmniejsz poziom zapasów.
• Przetwórz płatność: Wejdź w interakcję z bramką płatności.
• Powiadom dział wysyłki: Utwórz manifest wysyłki.

Jeśli wszystkie te czynności byłyby synchroniczne, klient czekałby długo na potwierdzenie, a aplikacja mogłaby stać się niereagująca pod obciążeniem.

Używanie Zadań w Tle:

1. Żądanie użytkownika dotyczące złożenia zamówienia jest obsługiwane przez FastAPI.
2. FastAPI natychmiast zwraca odpowiedź z potwierdzeniem zamówienia do użytkownika: „Twoje zamówienie zostało złożone i jest przetwarzane. Wkrótce otrzymasz wiadomość e-mail.”
3. Następujące zadania są dodawane do solidnej kolejki zadań (np. Celery):
• `send_order_confirmation_email(order_details)`: To zadanie obsługiwałoby i18n dla szablonów e-mail, biorąc pod uwagę ustawienia regionalne klienta.
• `update_inventory_service(order_items)`: Wywołanie mikroserwisu w celu aktualizacji zapasów, potencjalnie w różnych regionalnych magazynach.
• `process_payment_gateway(payment_details)`: Wchodzi w interakcje z procesorem płatności, który może mieć regionalne punkty końcowe. To zadanie potrzebuje solidnej obsługi błędów i logiki ponawiania.
• `generate_shipping_manifest(order_id, shipping_address)`: To zadanie przygotowuje dane dla działu wysyłki, biorąc pod uwagę przepisy celne kraju docelowego.

To asynchroniczne podejście zapewnia szybką odpowiedź dla klienta, zapobiega blokowaniu głównego API i pozwala na skalowalne, odporne przetwarzanie zamówień nawet w szczytowych globalnych sezonach zakupowych.

Wniosek

Asynchroniczne wykonywanie zadań jest kamieniem węgielnym budowania wysokowydajnych, skalowalnych i przyjaznych dla użytkownika aplikacji, zwłaszcza tych, które obsługują globalną publiczność. Python FastAPI, dzięki eleganckiej integracji zadań w tle, zapewnia solidny fundament. Dla prostych operacji typu „odpal i zapomnij”, wbudowana klasa `BackgroundTasks` FastAPI jest doskonałym punktem wyjścia.

Jednak w przypadku wymagających, krytycznych aplikacji, które wymagają odporności, trwałości i zaawansowanych funkcji, takich jak ponawianie, przetwarzanie rozproszone i solidne monitorowanie, niezbędna jest integracja z potężnymi systemami kolejek zadań, takimi jak Celery lub RQ. Starannie rozważając globalne czynniki, takie jak dystrybucja geograficzna, strefy czasowe, internacjonalizacja i solidna obsługa błędów, możesz wykorzystać zadania w tle do budowania prawdziwie wydajnych i niezawodnych usług internetowych dla użytkowników na całym świecie.

Opanowanie zadań w tle w FastAPI to nie tylko implementacja techniczna; to projektowanie systemów, które są responsywne, niezawodne i mogą skalować się, aby sprostać różnorodnym potrzebom globalnej bazy użytkowników.